package pers.bc.utils.ftp;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.Provider;
import java.security.Security;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;

import org.apache.commons.io.IOUtils;
import org.apache.commons.vfs.FileObject;
import org.apache.commons.vfs.FileSystemOptions;
import org.apache.commons.vfs.impl.StandardFileSystemManager;
import org.apache.commons.vfs.provider.sftp.SftpFileSystemConfigBuilder;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;

import net.schmizz.sshj.SSHClient;
import net.schmizz.sshj.sftp.SFTPClient;
import net.schmizz.sshj.transport.verification.PromiscuousVerifier;
import pers.bc.utils.constant.IPubCons;
import pers.bc.utils.pub.CollectionUtil;
import pers.bc.utils.pub.JsonUtil;
import pers.bc.utils.pub.JudgeAssertUtil;
import pers.bc.utils.pub.LoggerUtil;
import pers.bc.utils.pub.PropertiesUtil;
import pers.bc.utils.pub.PubEnvUtil;
import pers.bc.utils.pub.StringUtil;

/**
 * 类说明 sftp工具类 <br>
 * 本类工具：1、使用Java通过JSch库登录SFTP服务器<br>
 * 2、使用Java通过库登录SFTP服务器，这是一个纯Java的SSHv2库，支持SFTP，且不依赖JSch。s<br>
 * 3、CommonsVFS的SFTP实现是基于JSch的，因此不在使用 启动参数可能需要配置：<br>
 * -Djsch.client_pubkey=ssh-rsa,ssh-dss,ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-512,rsa-sha2-256<br>
 * -Djsch.server_host_key=ssh-rsa,ssh-dss,ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-512,rsa-sha2-256<br>
 * @qualiFild pers.bc.utils.ftp.SftpUtil.java<br>
 * @author：LiBencheng<br>
 * @date Created on 2025年3月12日<br>
 * @version 1.0<br>
 */
public class SftpUtil extends FTPConstant
{
    
    // static {
    // // 在程序启动时注册 Bouncy Castle 提供者：
    // Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    // }
    
    /*
     * 解决这个问题，你可以尝试以下方法：
        1. **确保Bouncy Castle库已经添加到项目中**：
           - 如果你是通过Maven或Gradle添加依赖，请检查pom.xml或build.gradle文件中是否正确添加了Bouncy Castle的依赖。
           - 如果你是手动添加Jar到项目中，请确保Jar文件正确放置在项目的类路径（classpath）中。
        2. **安装Bouncy Castle为安全提供者**：
           - 在代码中动态添加：
        
             import java.security.Security;
             import org.bouncycastle.jce.provider.BouncyCastleProvider;
             public class Main {
                 static {
                     Security.addProvider(new BouncyCastleProvider());
                 }
                 
                 public static void main(String[] args) {
                     // 你的代码
                 }
             }
           - 或者在Java的安全属性文件java.security中静态添加（该文件通常位于$JAVA_HOME/jre/lib/security/java.security或$JAVA_HOME/conf/security/java.security ，具体视Java版本而定）：
        
             security.provider.N=org.bouncycastle.jce.provider.BouncyCastleProvider
             其中N是安全提供者的顺序号，如果是添加新的提供者，请确保这个数字是接下来的未使用的编号。
        3. **更新/添加Java加密策略文件**：
           - 一些加密操作要求无限制的加密策略文件，确保你有合适版本的本地加密策略文件。对于Java 8之前的版本，你可能需要手动下载并替换这些文件，Java 8u151之后的版本可以通过更改$JAVA_HOME/jre/lib/security/java.security文件中的crypto.policy=unlimited设置来启用无限制策略。
        4. **确认Bouncy Castle版本与Java版本兼容**：
           - 如果你正在使用的Bouncy Castle版本过低或过高，可能不与当前Java版本兼容。请检查是否有适配你的Java环境的更合适的Bouncy Castle版本。
        若经过以上步骤问题仍未解决，建议重新检查错误详情、搜索具体的错误信息或询问社区，可能需要根据具体情况作出调整。

        。Java8兼容版本:Bouncy Castle 的 1.68 或更早版本(如 1.67、1.66 等)是专为 Java8 及以下设计的。
        。Java 11+ 兼容版本:从 1.69 开始，Bouncy Castle 要求最低 Java 11，因此不适用于 Java 8.

       */
    
    
    public String testSftp(Map map) throws Throwable
    {
        
        InputStream input = null;
        ChannelSftp channeClient = null;
        SFTPClient sftpClient = null;
        
        String isPrint = getPrintlog();
        try
        {
            Provider[] providers = Security.getProviders();
            System.out.println(StringUtil.toString(providers));
        }
        catch (Exception e)
        {
            debuglog(isPrint, "异常信息：" + e.getMessage());
        }
        
        try
        {
            debuglog(isPrint, "2、开始登录JSch_sftpClient服务器。。。");
            channeClient = login();
            debuglog(isPrint, "2、登录成功！JSch_sftpClient=" + channeClient);
        }
        catch (Throwable e)
        {
            String msg = "2、登录失败！JSch_sftpClient=" + channeClient + "异常信息：" + e.getMessage();
            debuglog(isPrint, msg);
            logUtil.exception(msg, e);
        }
        
        try
        {
            debuglog(isPrint, "4、开始登录vfs_sftp服务器。。。");
            vfsLogin();
            debuglog(isPrint, "4、登录成功！vfs_sftp");
        }
        catch (Throwable e)
        {
            String msg = "4、登录失败！vfs_sftp 异常信息：" + e.getMessage();
            debuglog(isPrint, msg);
            logUtil.exception(msg, e);
        }
        
        try
        {
            debuglog(isPrint, "1、开始登录sshj_sftp服务器。。。");
            sftpClient = sshjLogin();
            debuglog(isPrint, "1、登录成功！sshj_sftpClient=" + sftpClient);
            
        }
        catch (Throwable e)
        {
            String msg = "1、登录失败！sshj_sftpClient=" + sftpClient + "异常信息：" + e.getMessage();
            debuglog(isPrint, msg);
            logUtil.exception(msg, e);
        }
        
        return "";
    }
    
    public static void main(String[] args)
    {
        SftpUtil sftpUtil = null;
        try
        {
            String yhhdFileName = "D:\\ProgramData\\yonyou\\gongshangtouzi\\temp\\"//
                + "0200004519000100324_20221101_22305000011_0000#0045#00307#27656246_00001.pdf";
            String properPatch = "D:\\ProgramData\\yonyou\\gongshangtouzi\\icbcparam.properties";
            Map<String, String> map = PropertiesUtil.getAllProperties(properPatch);
            sftpUtil = getInstance(map);
            SFTPClient sshjSftp = sftpUtil.sshjLogin();
            System.err.println("sshjSftpUtil：" + sshjSftp);
            
            // ChannelSftp login = sftpUtil.login();
            // System.err.println("sftpUtil："+sftpUtil);
            // System.err.println("login："+login);
            
        }
        catch (Throwable e)
        {
            logUtil.exception(e);
        }
        finally
        {
            sftpUtil.logout();
            sftpUtil.sshjLogout();
        }
    }
    
    public static String DEBUG = "debug";
    
    private static String folderName = "sftplogs";
    private static LoggerUtil logUtil = LoggerUtil.getInstance(folderName);
    
    private ChannelSftp sftpChannel = null;
    
    private Session session;
    /** SFTP 登录用户名 */
    private String username;
    /** SFTP 登录密码 */
    private String password;
    /** 私钥 */
    private String privateKey;
    /** SFTP 服务器地址IP地址 */
    private String host;
    /** SFTP 端口 */
    private int port;
    private String passphrase;
    private String remoteFilePath;
    private String localFilePath;
    private String printlog;
    private String verifyHash;
    
    private String isPublickey;
    private String debug;
    
    private SSHClient sshClient = null;
    private SFTPClient sftpClient = null;
    
    public SSHClient getSshClient()
    {
        return sshClient;
    }
    
    public void setSshClient(SSHClient sshClient)
    {
        this.sshClient = sshClient;
    }
    
    public SFTPClient getSftpClient()
    {
        return sftpClient;
    }
    
    public void setSftpClient(SFTPClient sftpClient)
    {
        this.sftpClient = sftpClient;
    }
    
    /**
     * *********************************************************** <br>
     * 说明： 构造基于密码认证的sftp对象
     * @see
     * @param username
     * @param password
     * @param host
     * @param port
     * @methods pers.bc.utils.ftp.SftpUtil#构造方法
     * @author LiBencheng
     * @date Created on 2025年3月11日
     * @time 15:35:47
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public SftpUtil(String username, String password, String host, int port)
    {
        this.username = username;
        this.password = password;
        this.host = host;
        this.port = port;
    }
    
    /**
     * *********************************************************** <br>
     * 说明： 构造基于秘钥认证的sftp对象
     * @see
     * @param username
     * @param host
     * @param port
     * @param privateKey
     * @methods pers.bc.utils.ftp.SftpUtil#构造方法
     * @author LiBencheng
     * @date Created on 2025年3月11日
     * @time 15:35:53
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public SftpUtil(String username, String host, int port, String privateKey)
    {
        this.username = username;
        this.host = host;
        this.port = port;
        this.privateKey = privateKey;
    }
    
    public SftpUtil()
    {
    }
    
    /**
     * *********************************************************** <br>
     * *说明： 构造基于配置的sftp对象<br>
     * @see <br>
     * @param pram
     * @return <br>
     * @SftpUtil <br>
     * @methods pers.bc.utils.ftp.SftpUtil#getInstance <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月11日 <br>
     * @time 15:35:59 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public static SftpUtil getInstance(final Map pram)
    {
        return new SftpUtil()
        {
            {
                setHost(StringUtil.valueOfEmpty(pram.get(HOST)));
                setPort(Integer.parseInt(StringUtil.valueOfEmpty(pram.get(PORT))));
                setUsername(StringUtil.valueOfEmpty(pram.get(USER_NAME)));
                setPrivateKey(StringUtil.valueOfEmpty(pram.get(PRIVATE_KEY)));
                setPassword(StringUtil.valueOfEmpty(pram.get(PASSWORD)));
                setPassphrase(StringUtil.valueOfEmpty(pram.get(PASSPHRASE)));
                setRemoteFilePath(StringUtil.valueOfEmpty(pram.get(REMOTE_FILE_PATH)));
                setLocalFilePath(StringUtil.valueOfEmpty(pram.get(LOCAL_FILE_PATH)));
                setPrintlog(StringUtil.valueOfEmpty(pram.get(PRINT_LOG)));
                setVerifyHash(StringUtil.valueOfEmpty(pram.get(VERIFYHASH)));
                setIsPublickey(StringUtil.valueOfEmpty(pram.get(PUBLICKEY)));
                setDebug(StringUtil.valueOfEmpty(pram.get(DEBUG)));
                
            }
        };
    }
    
    /**
     * *********************************************************** <br>
     * *说明： 根据参数isPrintLog是否打印日志<br>
     * @see <br>
     * @param isPrintLog
     * @param msg <br>
     * @void <br>
     * @methods pers.bc.utils.ftp.SftpUtil#debuglog <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月11日 <br>
     * @time 15:43:15 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    private static void debuglog(String isPrintLog, String msg)
    {
        if (PubEnvUtil.equals(IPubCons.Y, isPrintLog.toLowerCase()) || PubEnvUtil.equals(IPubCons.TRUE, isPrintLog.toLowerCase()))
        {
            logUtil.info(msg);
            System.out.println(msg);
        }
    }
    
    /**
     * *********************************************************** <br>
     * *说明：sshj方式登录，用完必须调用sshjLogout（）sshj方式登出<br>
     * @see sshj.0.35.0.jar <br>
     * @return
     * @throws IOException <br>
     * @SFTPClient <br>
     * @methods pers.bc.utils.ftp.SftpUtil#sshjLogin <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月12日 <br>
     * @time 10:20:33 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public SFTPClient sshjLogin() throws Exception
    {
        SSHClient sshClient = null;
        SFTPClient sftpClient = null;
        String isPrint = getPrintlog();
        try
        {
            sshClient = new SSHClient();
            setSshClient(sshClient);
            debuglog(isPrint, "1、 配置 SSH 客户端，參數配置如下：" + JsonUtil.transObj2Josn(CollectionUtil.transBean2Map(this, true)));
            // 1. 配置 SSH 客户端（禁用主机密钥检查，仅用于测试）
            sshClient.addHostKeyVerifier(new PromiscuousVerifier());
            // sshClient.addHostKeyVerifier(new KnownHostsv);
            // sshClient.loadKnownHosts(); // 默认加载 ~/.ssh/known_hosts
            
            // // 1. 加载或创建 known_hosts 文件
            // File knownHostsFile = new File(System.getProperty("user.home") + "/.ssh/known_hosts");
            // sshClient.loadKnownHosts(knownHostsFile);
            
            // // 2. 添加自动接受新主机密钥的验证器
            // sshClient.addHostKeyVerifier(new OpenSSHKnownHosts(knownHostsFile) {
            // @Override
            // public boolean verify(String hostname, int port, PublicKey key) {
            // // 自动接受新密钥并保存到 known_hosts
            // final boolean verified = super.verify(hostname, port, key);
            // if (!verified) {
            // try {
            // this.write(new HostEntry(hostname, port, key));
            // } catch (IOException e) {
            // e.printStackTrace();
            // }
            // }
            // return true; // 始终返回 true 接受密钥（仅用于首次连接）
            // }
            // });
            
            debuglog(isPrint, "2、 SSH 连接connect ");
            sshClient.connect(getHost(), getPort());
            
            debuglog(isPrint, "3、 SSH 身份认证 ");
            
            if (PubEnvUtil.isNotEmptyObj(getPassword())) sshClient.authPassword(getUsername(), getPassword());
            if (PubEnvUtil.isNotEmptyObj(getPrivateKey()))
            {
                debuglog(isPrint, "3.2、 PrivateKey文件： " + getPrivateKey());
                File privateKeyFile = new File(getPrivateKey());
                sshClient.authPublickey(getUsername(), sshClient.loadKeys(privateKeyFile.getAbsolutePath()));
            }
            
            // net.schmizz.sshj.connection.channel.direct.Session startSession = sshClient.startSession();
            // Shell startShell = startSession.startShell();
            // StatefulSFTPClient sftpClient2 = sshClient.newStatefulSFTPClient();
            // SCPFileTransfer transfer = sshClient.newSCPFileTransfer();
            // SCPDownloadClient downloadClient = transfer.newSCPDownloadClient();
            // downloadClient.copy(isPrint, null);
            
            debuglog(isPrint, "4、 创建 SFTP 客户端 ");
            sftpClient = sshClient.newSFTPClient();
            setSftpClient(sftpClient);
            debuglog(isPrint, "5、 SFTP 客户端已创建 sshClient：" + sshClient);
            // sftpClient.get(linuxFilePath, localFileDirectory);
            debuglog(isPrint, "6、 示例操作：列出远程目录文件，列出目录内容: " + getRemoteFilePath());
            // sftpClient.ls(sftpUtil.getRemoteFilePath()) .forEach(entry -> {
            // debuglog(isPrint,entry.getName());});
            
        }
        catch (IOException e)
        {
            debuglog(isPrint, "00、登录失败...." + e.getMessage());
            // 关闭连接
            if (PubEnvUtil.isNotNullObj(sftpClient))
            {
                sftpClient.close();
                sshClient.disconnect();
            }
            JudgeAssertUtil.throwExceptionDir(e, folderName);
        }
        
        return sftpClient;
    }
    
    /**
     * *********************************************************** <br>
     * *说明：sshj方式登出 <br>
     * @see <br>
     *      <br>
     * @void <br>
     * @methods pers.bc.utils.ftp.SftpUtil#sshjLogout <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月12日 <br>
     * @time 10:22:43 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public void sshjLogout()
    {
        try
        {
            if (PubEnvUtil.isNotNullObj(getSftpClient())) getSftpClient().close();
            if (PubEnvUtil.isNotNullObj(getSshClient())) getSshClient().disconnect();
        }
        catch (IOException e)
        {
            logUtil.exception("sshjLogout退出登录异常：", e);
        }
        
    }
    
    /**
     * *********************************************************** <br>
     * *说明： <br>
     * @see <br>
     *      <br>
     * @void <br>
     * @methods nc.impl.obm.ebankyhhd.SftpUtil#vfsLogin <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月13日 <br>
     * @time 11:08:23 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public void vfsLogin()
    {
        
        // 1. 初始化文件系统管理器
        try
        {
            debuglog(printlog, "1. 初始化文件系统管理器");
            StandardFileSystemManager fsManager = new StandardFileSystemManager();
            fsManager.init();
            
            debuglog(printlog, "2. 配置 SFTP 选项");
            // 2. 配置 SFTP 选项
            FileSystemOptions opts = new FileSystemOptions();
            // SftpFileSystemConfigBuilder instance = SftpFileSystemConfigBuilder.getInstance();
            SftpFileSystemConfigBuilder.getInstance().setStrictHostKeyChecking(opts, "no"); // 禁用严格主机密钥检查（仅测试）
            // SftpFileSystemConfigBuilder.getInstance().setKnownHosts(opts, new File("known_hosts"));//
            // 使用已知主机文件（如 ~/.ssh/known_hosts）
            SftpFileSystemConfigBuilder.getInstance().setUserDirIsRoot(opts, false); // 使用绝对路径
            // SftpFileSystemConfigBuilder.getInstance().setIdentityProvider(opts, getPrivateKey());
            
            debuglog(printlog, "5. 配置密钥路径和密码 ");
            // 配置密钥路径和密码（若有）
            SftpFileSystemConfigBuilder.getInstance().setIdentities(opts, new File[]{new File(getPrivateKey())});
            // // 若私钥有密码
            // SftpFileSystemConfigBuilder.getInstance().setUserInfo(opts, new StaticUserInfo(password));
            
            debuglog(printlog, "4. 构建 SFTP URL");
            // 3. 构建 SFTP URL
            String sftpUri = String.format(
                // "sftp://%s:%s@%s:%d%s",
                // username, password, host, port, remoteDir
                "sftp://%s@%s", username, host, port);
            
            debuglog(printlog, "5. 获取远程文件对象");
            // 4. 获取远程文件对象
            FileObject remoteFolder = fsManager.resolveFile(sftpUri, opts);
            
            debuglog(printlog, "6. 获取远程文件对象remoteFolder: " + remoteFolder);
            FileObject child = remoteFolder.getChild("");
            
            // 5. 示例操作：列出目录文件
            // System.out.println("Listing files in " + remoteDir);
            // for (FileObject file : remoteFolder.getChildren()) {
            // System.out.println(file.getName().getBaseName());
            // }
            
            // FileObject localFileObj = fsManager.resolveFile(localFile);
            // 6. 文件上传示例
            // FileObject remoteFileObj = fsManager.resolveFile(remoteFile, opts);
            // remoteFileObj.copyFrom(localFileObj, Selectors.SELECT_SELF);
            // System.out.println("File uploaded successfully");
            
            // 7. 文件下载示例（反向操作）
            // localFileObj.copyFrom(remoteFileObj, Selectors.SELECT_SELF);
            
        }
        catch (Exception e)
        {
            debuglog(printlog, "00. 链接文件服务器失败：" + e.getMessage());
            JudgeAssertUtil.throwExceptionDir(e, folderName);
        }
    }
    
    /**
     * *********************************************************** <br>
     * *说明：连接sftp服务器 <br>
     * @see jsch.jar <br>
     * @return <br>
     * @ChannelSftp <br>
     * @methods pers.bc.utils.ftp.SftpUtil#login <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月11日 <br>
     * @time 15:43:39 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public ChannelSftp login()
    {
        try
        {
            debuglog(printlog, "1、登录开始....Create JSch session ");
            debuglog(printlog, "2、SSH configure session parameters....");
            JSch jsch = new JSch();
            
            if (PubEnvUtil.isNotEmptyObj(privateKey)) jsch.addIdentity(privateKey);// 设置私钥
            
            session = jsch.getSession(username, host, port);
            
            if (PubEnvUtil.isNotEmptyObj(password)) session.setPassword(password);
            
            Properties config = new Properties();
            if (PubEnvUtil.equals(IPubCons.Y, debug.toLowerCase()) || PubEnvUtil.equals(IPubCons.TRUE, debug.toLowerCase()))
                config.put("debug", "true");
            config.put("StrictHostKeyChecking", "no");
            if (PubEnvUtil.equals(IPubCons.Y, isPublickey.toLowerCase()) || PubEnvUtil.equals(IPubCons.TRUE, isPublickey.toLowerCase()))
                config.put("PreferredAuthentications", "publickey"); // 仅使用公钥认证方式
            session.setConfig(config);
            
            debuglog(printlog, "3、Start establishing SSH link....");
            session.connect();
            Channel channel = session.openChannel("sftp");
            
            debuglog(printlog, "4、SFTP channel opened.....");
            channel.connect();
            sftpChannel = (ChannelSftp) channel;
            
            debuglog(printlog, "5、登录成功....");
            
            return sftpChannel;
        }
        catch (JSchException e)
        {
            // 关闭连接
            logout();
            debuglog(printlog, "00、登录失败...." + e.getMessage());
            JudgeAssertUtil.throwExceptionDir(e, folderName);
        }
        // finally
        // {
        // // 关闭连接
        // if (sftpChannel != null && sftpChannel.isConnected())
        // sftpChannel.disconnect();
        // if (session != null && session.isConnected())
        // session.disconnect();
        // }
        return sftpChannel;
    }
    
    /**
     * *********************************************************** <br>
     * *说明：关闭连接 server <br>
     * @see <br>
     *      <br>
     * @void <br>
     * @methods pers.bc.utils.ftp.SftpUtil#logout <br>
     * @author LiBencheng <br>
     * @date Created on 2025年3月11日 <br>
     * @time 15:43:45 <br>
     * @version 1.0 <br>
     *************************************************************          <br>
     */
    public void logout()
    {
        // 关闭连接
        if (sftpChannel != null && sftpChannel.isConnected())
        {
            sftpChannel.disconnect();
        }
        if (session != null && session.isConnected())
        {
            session.disconnect();
        }
        
    }
    
    /**
     * 将输入流的数据上传到sftp作为文件。文件完整路径=basePath+directory
     * 
     * @param basePath 服务器的基础路径
     * @param directory 上传到该目录
     * @param sftpFileName sftp端文件名
     * @param in 输入流
     */
    public void upload(String basePath, String directory, String sftpFileName, InputStream input) throws SftpException
    {
        try
        {
            sftpChannel.cd(basePath);
            sftpChannel.cd(directory);
        }
        catch (SftpException e)
        {
            // 目录不存在，则创建文件夹
            String[] dirs = directory.split("/");
            String tempPath = basePath;
            for (String dir : dirs)
            {
                if (null == dir || "".equals(dir)) continue;
                tempPath += "/" + dir;
                try
                {
                    sftpChannel.cd(tempPath);
                }
                catch (SftpException ex)
                {
                    sftpChannel.mkdir(tempPath);
                    sftpChannel.cd(tempPath);
                }
            }
        }
        sftpChannel.put(input, sftpFileName); // 上传文件
    }
    
    /**
     * 下载文件。
     * 
     * @param directory 下载目录
     * @param downloadFile 下载的文件
     * @param saveFile 存在本地的路径
     */
    public void download(String directory, String downloadFile, String saveFile) throws SftpException, FileNotFoundException
    {
        if (directory != null && !"".equals(directory))
        {
            sftpChannel.cd(directory);
        }
        File file = new File(saveFile);
        sftpChannel.get(downloadFile, new FileOutputStream(file));
    }
    
    /**
     * 下载文件
     * 
     * @param directory 下载目录
     * @param downloadFile 下载的文件名
     * @return String
     */
    public String download(String directory, String downloadFile) throws SftpException, IOException
    {
        if (directory != null && !"".equals(directory))
        {
            sftpChannel.cd(directory);
        }
        InputStream is = sftpChannel.get(downloadFile);
        
        String fileData = IOUtils.toString(is, "UTF-8");
        
        return fileData;
    }
    
    /**
     * 下载文件
     * 
     * @param directory 下载目录
     * @param downloadFile 下载的文件名
     * @return String
     */
    public InputStream downloadReturnIn(String directory, String downloadFile) throws SftpException, IOException
    {
        if (directory != null && !"".equals(directory))
        {
            sftpChannel.cd(directory);
        }
        InputStream is = sftpChannel.get(downloadFile);
        String fileData = IOUtils.toString(is, "UTF-8");
        is = IOUtils.toInputStream(fileData, "UTF-8");
        return is;
    }
    
    /**
     * 删除文件
     * 
     * @param directory 要删除文件所在目录
     * @param deleteFile 要删除的文件
     */
    public void delete(String directory, String deleteFile) throws SftpException
    {
        sftpChannel.cd(directory);
        sftpChannel.rm(deleteFile);
    }
    
    /**
     * 列出目录下的文件
     * 
     * @param directory 要列出的目录
     * @param sftp
     */
    public Vector<?> listFiles(String directory) throws SftpException
    {
        return sftpChannel.ls(directory);
    }
    
    /**
     * 
     * @param user 登录用户名
     * @param password 登录密码
     * @param ip sftp 地址
     * @param port 端口
     * @param directory 文件路径
     * @param downloadFile 文件名
     * @return
     * @throws SftpException
     * @throws IOException
     */
    public String getSftp(String user, String password, String ip, int port, String directory, String downloadFile, String keypath,
            String issecret) throws SftpException, IOException
    {
        SftpUtil sftp;
        // String username, String host, int port, String privateKey
        if (issecret.equals("0"))
        {
            sftp = new SftpUtil(user, ip, port, keypath);
        }
        else
        {
            sftp = new SftpUtil(user, password, ip, port);
        }
        sftp.login();
        String xml = sftp.download(directory, downloadFile);
        sftp.logout();
        return xml;
    }
    
    /**
     * 
     * @param user登录用户名
     * 
     * @param password登录密码
     * @param ip IP地址
     * @param port 端口
     * @param directory 上传文件存储文件夹
     * @param sftpFileName 上传文件名
     * @param basePath 上传文件存储文件路径
     * @param input 文件流
     * @throws SftpException
     * @throws IOException
     */
    public void uploadSftp(String user, String password, String ip, int port, String directory, String sftpFileName, String basePath,
            InputStream input, String keypath, String issecret) throws SftpException, IOException
    {
        SftpUtil sftp;
        if (issecret.equals("0"))
        {
            sftp = new SftpUtil(user, ip, port, keypath);
        }
        else
        {
            sftp = new SftpUtil(user, password, ip, port);
        }
        sftp.login();
        sftp.upload(basePath, directory, sftpFileName, input);
        sftp.logout();
    }
    
    public String getPrintlog()
    {
        return printlog;
    }
    
    public void setPrintlog(String printlog)
    {
        this.printlog = printlog;
    }
    
    public String getVerifyHash()
    {
        return verifyHash;
    }
    
    public void setVerifyHash(String verifyHash)
    {
        this.verifyHash = verifyHash;
    }
    
    // Getters and Setters
    public String getHost()
    {
        return host;
    }
    
    public void setHost(String host)
    {
        this.host = host;
    }
    
    public int getPort()
    {
        return port;
    }
    
    public void setPort(int port)
    {
        this.port = port;
    }
    
    public String getUsername()
    {
        return username;
    }
    
    public void setUsername(String username)
    {
        this.username = username;
    }
    
    public String getPassword()
    {
        return password;
    }
    
    public void setPassword(String password)
    {
        this.password = password;
    }
    
    public String getPrivateKey()
    {
        return privateKey;
    }
    
    public void setPrivateKey(String privateKey)
    {
        this.privateKey = privateKey;
    }
    
    public String getPassphrase()
    {
        return passphrase;
    }
    
    public void setPassphrase(String passphrase)
    {
        this.passphrase = passphrase;
    }
    
    public String getRemoteFilePath()
    {
        return remoteFilePath;
    }
    
    public void setRemoteFilePath(String remoteFilePath)
    {
        this.remoteFilePath = remoteFilePath;
    }
    
    public String getLocalFilePath()
    {
        return localFilePath;
    }
    
    public void setLocalFilePath(String localFilePath)
    {
        this.localFilePath = localFilePath;
    }
    
    public String isPublickey()
    {
        return isPublickey;
    }
    
    public void setIsPublickey(String publickey)
    {
        this.isPublickey = publickey;
    }
    
    public String getDebug()
    {
        return debug;
    }
    
    public void setDebug(String debug)
    {
        this.debug = debug;
    }
    
}
